home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 2001 May / SGI Freeware 2001 May - Disc 1.iso / dist / fw_mysql.idb / usr / freeware / include / mysql / my_sys.h.z / my_sys.h
Encoding:
C/C++ Source or Header  |  1999-10-18  |  19.2 KB  |  488 lines
  1. /* Copyright Abandoned 1996 TCX DataKonsult AB & Monty Program KB & Detron HB
  2.    This file is public domain and comes with NO WARRANTY of any kind */
  3.  
  4. #ifndef _my_sys_h
  5. #define _my_sys_h
  6. #ifdef    __cplusplus
  7. extern "C" {
  8. #endif
  9.  
  10. #ifdef HAVE_AIOWAIT
  11. #include <sys/asynch.h>            /* Used by record-cache */
  12. typedef struct my_aio_result {
  13.   aio_result_t result;
  14.   int           pending;
  15. } my_aio_result;
  16. #endif
  17.  
  18. #ifndef THREAD
  19. extern int NEAR my_errno;        /* Last error in mysys */
  20. #else
  21. #include <my_pthread.h>
  22. #endif
  23.  
  24. #define MYSYS_PROGRAM_USES_CURSES()  { error_handler_hook = my_message_curses;    mysys_uses_curses=1; }
  25. #define MYSYS_PROGRAM_DONT_USE_CURSES()  { error_handler_hook = my_message_no_curses; mysys_uses_curses=0;}
  26. #define MY_INIT(name);        { my_progname= name; my_init(); }
  27.  
  28. #define MAXMAPS        (4)    /* Number of error message maps */
  29. #define ERRMOD        (1000)    /* Max number of errors in a map */
  30. #define ERRMSGSIZE    (SC_MAXWIDTH)    /* Max length of a error message */
  31. #define NRERRBUFFS    (2)    /* Buffers for parameters */
  32. #define MY_FILE_ERROR    ((uint) ~0)
  33.  
  34.     /* General bitmaps for my_func's */
  35. #define MY_FFNF        1    /* Fatal if file not found */
  36. #define MY_FNABP    2    /* Fatal if not all bytes read/writen */
  37. #define MY_NABP        4    /* Error if not all bytes read/writen */
  38. #define MY_FAE        8    /* Fatal if any error */
  39. #define MY_WME        16    /* Write message on error */
  40. #define MY_WAIT_IF_FULL 32    /* Wait and try again if disk full error */
  41. #define MY_LINK_WARNING 32    /* my_redel() gives warning if links */
  42. #define MY_COPYTIME    64    /* my_redel() copys time */
  43. #define MY_HOLD_ORIGINAL_MODES 128  /* my_copy() holds to file modes */
  44. #define MY_SEEK_NOT_DONE 32    /* my_lock may have to do a seek */
  45. #define MY_DONT_WAIT    64    /* my_lock() don't wait if can't lock */
  46. #define MY_ZEROFILL    32    /* my_malloc(), fill array with zero */
  47. #define MY_ALLOW_ZERO_PTR 64    /* my_realloc() ; zero ptr -> malloc */
  48. #define MY_FREE_ON_ERROR 128    /* my_realloc() ; Free old ptr on error */
  49. #define MY_HOLD_ON_ERROR 256    /* my_realloc() ; Return old ptr on error */
  50.  
  51. #define MY_CHECK_ERROR    1    /* Params to my_end; Check open-close */
  52. #define MY_GIVE_INFO    2    /* Give time info about process*/
  53.  
  54. #define ME_HIGHBYTE    8    /* Shift for colours */
  55. #define ME_NOCUR    1    /* Don't use curses message */
  56. #define ME_OLDWIN    2    /* Use old window */
  57. #define ME_BELL        4    /* Ring bell then printing message */
  58. #define ME_HOLDTANG    8    /* Don't delete last keys */
  59. #define ME_WAITTOT    16    /* Wait for errtime secs of for a action */
  60. #define ME_WAITTANG    32    /* Wait for a user action  */
  61. #define ME_NOREFRESH    64    /* Dont refresh screen */
  62. #define ME_NOINPUT    128    /* Dont use the input libary */
  63. #define ME_COLOUR1    ((1 << ME_HIGHBYTE))    /* Possibly error-colours */
  64. #define ME_COLOUR2    ((2 << ME_HIGHBYTE))
  65. #define ME_COLOUR3    ((3 << ME_HIGHBYTE))
  66.  
  67.     /* My seek flags */
  68. #define MY_SEEK_SET    0
  69. #define MY_SEEK_CUR    1
  70. #define MY_SEEK_END    2
  71.  
  72.     /* Some constants */
  73. #define MY_WAIT_FOR_USER_TO_FIX_PANIC    60    /* in seconds */
  74. #define MY_WAIT_GIVE_USER_A_MESSAGE    10    /* Every 10 times of prev */
  75. #define MIN_COMPRESS_LENGTH        50    /* Don't compress small bl. */
  76.  
  77.     /* defines when allocating data */
  78.  
  79. #ifdef SAFEMALLOC
  80. #define my_malloc(SZ,FLAG) _mymalloc( SZ, __FILE__, __LINE__, FLAG )
  81. #define my_realloc(PTR,SZ,FLAG) _myrealloc( PTR, SZ, __FILE__, __LINE__, FLAG )
  82. #define my_checkmalloc() _sanity( __FILE__, __LINE__ )
  83. #define my_free(PTR,FLAG) _myfree( PTR, __FILE__, __LINE__,FLAG)
  84. #define my_memdup(A,B,C) _my_memdup(A,B,__FILE__,__LINE__,C)
  85. #define my_strdup(A,C) _my_strdup(A,__FILE__,__LINE__,C)
  86. #define QUICK_SAFEMALLOC sf_malloc_quick=1
  87. #define NORMAL_SAFEMALLOC sf_malloc_quick=0
  88. extern uint sf_malloc_prehunc,sf_malloc_endhunc,sf_malloc_quick;
  89. #else
  90. #define my_checkmalloc() (0)
  91. #define TERMINATE(A) {}
  92. #define QUICK_SAFEMALLOC
  93. #define NORMAL_SAFEMALLOC
  94. extern gptr my_malloc(uint Size,myf MyFlags);
  95. extern gptr my_realloc(gptr oldpoint,uint Size,myf MyFlags);
  96. extern void my_no_flags_free(gptr ptr);
  97. extern gptr my_memdup(const byte *from,uint length,myf MyFlags);
  98. extern my_string my_strdup(const char *from,myf MyFlags);
  99. #define my_free(PTR,FG) my_no_flags_free(PTR)
  100. #endif
  101. #ifdef HAVE_ALLOCA
  102. #define my_alloca(SZ) alloca((size_t) (SZ))
  103. #define my_afree(PTR) {}
  104. #else
  105. #define my_alloca(SZ) my_malloc(SZ,MYF(0))
  106. #define my_afree(PTR) my_free(PTR,MYF(MY_WME))
  107. #endif /* HAVE_ALLOCA */
  108. #ifdef MSDOS
  109. #ifdef __ZTC__
  110. void * __CDECL halloc(long count,size_t length);
  111. void   __CDECL hfree(void *ptr);
  112. #endif
  113. #if defined(USE_HALLOC)
  114. #if defined(_VCM_) || defined(M_IC80386)
  115. #undef USE_HALLOC
  116. #endif
  117. #endif
  118. #ifdef USE_HALLOC
  119. #define malloc(a) halloc((long) (a),1)
  120. #define free(a) hfree(a)
  121. #endif
  122. #endif /* MSDOS */
  123.  
  124.  
  125. #ifdef HAVE_ERRNO_AS_DEFINE
  126. #include <errno.h>            /* errno is a define */
  127. #else
  128. extern int errno;            /* declare errno */
  129. #endif
  130. extern char ** NEAR errmsg[];
  131. extern char NEAR errbuff[NRERRBUFFS][ERRMSGSIZE];
  132. extern char *home_dir;            /* Home directory for user */
  133. extern char *my_progname;        /* program-name (printed in errors) */
  134. extern char NEAR curr_dir[];        /* Current directory for user */
  135. extern int (*error_handler_hook)(uint my_error, const char *str,myf MyFlags);
  136. extern int (*fatal_error_handler_hook)(uint my_error, const char *str,
  137.                        myf MyFlags);
  138.  
  139.                     /* Point to current my_message() */
  140. extern void (*my_sigtstp_cleanup)(void),
  141.                     /* Executed before jump to shell */
  142.         (*my_sigtstp_restart)(void),
  143.         (*my_abort_hook)(int);
  144.                     /* Executed when comming from shell */
  145. extern int NEAR my_umask,        /* Default creation mask  */
  146.        NEAR my_recived_signals,    /* Signals we have got */
  147.        NEAR my_safe_to_handle_signal, /* Set when allowed to SIGTSTP */
  148.        NEAR my_dont_interrupt;    /* call remember_intr when set */
  149. extern my_bool NEAR mysys_uses_curses;
  150. extern long lCurMemory,lMaxMemory;    /* from safemalloc */
  151.  
  152. extern ulong    my_default_record_cache_size;
  153. extern my_bool NEAR my_disable_locking,NEAR my_disable_async_io,
  154.        NEAR my_disable_flush_key_blocks;
  155. extern char    wild_many,wild_one,wild_prefix;
  156.  
  157. typedef struct wild_file_pack    /* Struct to hold info when selecting files */
  158. {
  159.   uint        wilds;        /* How many wildcards */
  160.   uint        not_pos;    /* Start of not-theese-files */
  161.   my_string    *wild;        /* Pointer to wildcards */
  162. } WF_PACK;
  163.  
  164. typedef struct st_typelib {    /* Different types saved here */
  165.   uint count;            /* How many types */
  166.   my_string name;            /* Name of typelib */
  167.   my_string *type_names;
  168. } TYPELIB;
  169.  
  170. enum cache_type {READ_CACHE,WRITE_CACHE,READ_NET,WRITE_NET};
  171.  
  172. typedef struct st_record_cache    /* Used when cacheing records */
  173. {
  174.   File file;
  175.   int    rc_seek,error,inited;
  176.   uint    rc_length,read_length,reclength;
  177.   my_off_t rc_record_pos,end_of_file;
  178.   byte    *rc_buff,*rc_buff2,*rc_pos,*rc_end,*rc_request_pos;
  179. #ifdef HAVE_AIOWAIT
  180.   int    use_async_io;
  181.   my_aio_result aio_result;
  182. #endif
  183.   enum cache_type type;
  184. } RECORD_CACHE;
  185.  
  186. enum file_type { UNOPEN = 0, FILE_BY_OPEN, FILE_BY_CREATE,
  187.            STREAM_BY_FOPEN, STREAM_BY_FDOPEN };
  188.  
  189. extern struct my_file_info
  190. {
  191.   my_string        name;
  192.   enum file_type    type;
  193. } my_file_info[MY_NFILE];
  194.  
  195.  
  196. typedef struct st_dynamic_array {
  197.   char *buffer;
  198.   uint elements,max_element;
  199.   uint alloc_increment;
  200.   uint size_of_element;
  201. } DYNAMIC_ARRAY;
  202.  
  203. typedef struct st_dynamic_string {
  204.   char *str;
  205.   uint length,max_length,alloc_increment;
  206. } DYNAMIC_STRING;
  207.  
  208.  
  209. typedef struct st_io_cache        /* Used when cacheing files */
  210. {
  211.   byte    *rc_pos,*rc_end,*buffer,*rc_request_pos;
  212.   File file;
  213.   int    seek_not_done,error;
  214.   uint    buffer_length,read_length;
  215.   my_off_t pos_in_file,end_of_file;
  216.   myf    myflags;            /* Flags used to my_read/my_write */
  217. #ifdef HAVE_AIOWAIT
  218.   uint inited;
  219.   my_off_t aio_read_pos;
  220.   my_aio_result aio_result;
  221. #endif
  222.   enum cache_type type;
  223.   int (*read_function)(struct st_io_cache *,byte *,uint);
  224.   char *file_name;            /* if used with 'open_cacheed_file' */
  225. } IO_CACHE;
  226.  
  227.     /* defines for mf_iocache */
  228.  
  229.     /* Test if buffer is inited */
  230. #define my_b_clear(info) (info)->buffer=0
  231. #define my_b_inited(info) (info)->buffer
  232. #define my_b_EOF INT_MIN
  233.  
  234. #define my_b_read(info,Buffer,Count) \
  235.   ((info)->rc_pos + (Count) <= (info)->rc_end ?\
  236.    (memcpy(Buffer,(info)->rc_pos,(size_t) (Count)), \
  237.     ((info)->rc_pos+=(Count)),0) :\
  238.    (*(info)->read_function)((info),Buffer,Count))
  239.  
  240. #define my_b_get(info) \
  241.   ((info)->rc_pos != (info)->rc_end ?\
  242.    ((info)->rc_pos++, (int) (info)->rc_pos[-1]) :\
  243.    _my_b_get(info))
  244.  
  245. #define my_b_write(info,Buffer,Count) \
  246.   ((info)->rc_pos + (Count) <= (info)->rc_end ?\
  247.    (memcpy((info)->rc_pos,Buffer,(size_t) (Count)), \
  248.     ((info)->rc_pos+=(Count)),0) :\
  249.    _my_b_write(info,Buffer,Count))
  250.  
  251.     /* my_b_write_byte dosn't have any err-check */
  252. #define my_b_write_byte(info,chr) \
  253.   (((info)->rc_pos < (info)->rc_end) ?\
  254.    ((*(info)->rc_pos++)=(chr)) :\
  255.    (_my_b_write(info,0,0) , ((*(info)->rc_pos++)=(chr))))
  256.  
  257. #define my_b_fill_cache(info) \
  258.   (((info)->rc_end=(info)->rc_pos),(*(info)->read_function)(info,0,0))
  259.  
  260. #define my_b_tell(info) ((info)->pos_in_file + \
  261.              ((info)->rc_pos - (info)->rc_request_pos))
  262.  
  263. typedef struct st_changeable_var {
  264.   const char *name;
  265.   long *varptr;
  266.   long def_value,min_value,max_value,sub_size,block_size;
  267. } CHANGEABLE_VAR;
  268.  
  269.  
  270. /* structs for alloc_root */
  271.  
  272. #ifndef ST_USED_MEM_DEFINED
  273. #define ST_USED_MEM_DEFINED
  274. typedef struct st_used_mem {            /* struct for once_alloc */
  275.   struct st_used_mem *next;            /* Next block in use */
  276.   unsigned int    left;                /* memory left in block  */
  277.   unsigned int    size;                /* size of block */
  278. } USED_MEM;
  279.  
  280. typedef struct st_mem_root {
  281.   USED_MEM *free;
  282.   USED_MEM *used;
  283.   unsigned int    min_malloc;
  284.   unsigned int    block_size;
  285.   void (*error_handler)(void);
  286. } MEM_ROOT;
  287. #endif
  288.  
  289.     /* Prototypes for mysys and my_func functions */
  290.  
  291. extern int my_copy(const char *from,const char *to,myf MyFlags);
  292. extern int my_append(const char *from,const char *to,myf MyFlags);
  293. extern int my_delete(const char *name,myf MyFlags);
  294. extern int my_getwd(my_string buf,uint size,myf MyFlags);
  295. extern int my_setwd(const char *dir,myf MyFlags);
  296. extern int my_lock(File fd,int op,my_off_t start, my_off_t length,myf MyFlags);
  297. extern gptr my_once_alloc(uint Size,myf MyFlags);
  298. extern void my_once_free(void);
  299. extern my_string my_tempnam(const char *dir,const char *pfx,myf MyFlags);
  300. extern File my_open(const char *FileName,int Flags,myf MyFlags);
  301. extern File my_create(const char *FileName,int CreateFlags,
  302.               int AccsesFlags, myf MyFlags);
  303. extern int my_close(File Filedes,myf MyFlags);
  304. extern int my_mkdir(const char *dir, int Flags, myf MyFlags);
  305. extern uint my_read(File Filedes,byte *Buffer,uint Count,myf MyFlags);
  306. extern uint my_pread(File Filedes,byte *Buffer,uint Count,my_off_t offset,
  307.              myf MyFlags);
  308. extern int my_rename(const char *from,const char *to,myf MyFlags);
  309. extern my_off_t my_seek(File fd,my_off_t pos,int whence,myf MyFlags);
  310. extern my_off_t my_tell(File fd,myf MyFlags);
  311. extern uint my_write(File Filedes,const byte *Buffer,uint Count,
  312.              myf MyFlags);
  313. extern uint my_pwrite(File Filedes,const byte *Buffer,uint Count,
  314.               my_off_t offset,myf MyFlags);
  315. extern uint my_fread(FILE *stream,byte *Buffer,uint Count,myf MyFlags);
  316. extern uint my_fwrite(FILE *stream,const byte *Buffer,uint Count,
  317.               myf MyFlags);
  318. extern my_off_t my_fseek(FILE *stream,my_off_t pos,int whence,myf MyFlags);
  319. extern my_off_t my_ftell(FILE *stream,myf MyFlags);
  320. extern gptr _mymalloc(uint uSize,const char *sFile,
  321.               uint uLine, myf MyFlag);
  322. extern gptr _myrealloc(my_string pPtr,uint uSize,const char *sFile,
  323.                uint uLine, myf MyFlag);
  324. extern gptr my_multi_malloc _VARARGS((myf MyFlags, ...));
  325. extern void _myfree(gptr pPtr,const char *sFile,uint uLine, myf MyFlag);
  326. extern int _sanity(const char *sFile,unsigned int uLine);
  327. extern gptr _my_memdup(const byte *from,uint length,
  328.                const char *sFile, uint uLine,myf MyFlag);
  329. extern my_string _my_strdup(const char *from, const char *sFile, uint uLine,
  330.                 myf MyFlag);
  331. #ifndef TERMINATE
  332. extern void TERMINATE(FILE *file);
  333. #endif
  334. extern void init_glob_errs(void);
  335. extern FILE *my_fopen(const char *FileName,int Flags,myf MyFlags);
  336. extern FILE *my_fdopen(File Filedes,int Flags,myf MyFlags);
  337. extern int my_fclose(FILE *fd,myf MyFlags);
  338. extern int my_chsize(File fd,my_off_t newlength,myf MyFlags);
  339. extern int my_error _VARARGS((int nr,myf MyFlags, ...));
  340. extern int my_printf_error _VARARGS((uint my_error, const my_string format,
  341.                      myf MyFlags, ...));
  342. extern int my_message(uint my_error, const char *str,myf MyFlags);
  343. extern int my_message_no_curses(uint my_error, const char *str,myf MyFlags);
  344. extern int my_message_curses(uint my_error, const char *str,myf MyFlags);
  345. extern void my_init(void);
  346. extern void my_end(int infoflag);
  347. extern int my_redel(const char *from, const char *to, int MyFlags);
  348. extern int my_copystat(const char *from, const char *to, int MyFlags);
  349. extern my_string my_filename(File fd);
  350.  
  351. extern void dont_break(void);
  352. extern void allow_break(void);
  353. extern void my_remember_signal(int signal_number,sig_handler (*func)(int));
  354. extern void caseup(my_string str,uint length);
  355. extern void casedn(my_string str,uint length);
  356. extern void caseup_str(my_string str);
  357. extern void casedn_str(my_string str);
  358. extern void case_sort(my_string str,uint length);
  359. extern uint dirname_part(my_string to,const char *name);
  360. extern uint dirname_length(const char *name);
  361. #define base_name(A) (A+dirname_length(A))
  362. extern int test_if_hard_path(const char *dir_name);
  363. extern void convert_dirname(my_string name);
  364. extern void to_unix_path(my_string name);
  365. extern my_string fn_ext(const char *name);
  366. extern my_string fn_same(my_string toname,const char *name,int flag);
  367. extern my_string fn_format(my_string to,const char *name,const char *dsk,
  368.                const char *form,int flag);
  369. extern size_s strlength(const char *str);
  370. extern void pack_dirname(my_string to,const char *from);
  371. extern uint unpack_dirname(my_string to,const char *from);
  372. extern uint cleanup_dirname(my_string to,const char *from);
  373. extern uint system_filename(my_string to,const char *from);
  374. extern my_string unpack_filename(my_string to,const char *from);
  375. extern my_string intern_filename(my_string to,const char *from);
  376. extern my_string directory_file_name(my_string dst, my_string src);
  377. extern int pack_filename(my_string to, my_string name, size_s max_length);
  378. extern my_string my_path(my_string to,const char *progname,
  379.              const char *own_pathname_part);
  380. extern my_string my_load_path(my_string to, const char *path,
  381.                   const char *own_path_prefix);
  382. extern int wild_compare(const char *str,const char *wildstr);
  383. extern my_string strcasestr(const char *src,const char *suffix);
  384. extern int my_strcasecmp(const char *s,const char *t);
  385. extern int my_strsortcmp(const char *s,const char *t);
  386. extern int my_casecmp(const char *s,const char *t,uint length);
  387. extern int my_sortcmp(const char *s,const char *t,uint length);
  388. extern WF_PACK *wf_comp(my_string str);
  389. extern int wf_test(struct wild_file_pack *wf_pack,const char *name);
  390. extern void wf_end(struct wild_file_pack *buffer);
  391. extern size_s stripp_sp(my_string str);
  392. extern void get_date(my_string to,int timeflag,time_t use_time);
  393. extern void soundex(my_string out_pntr, my_string in_pntr,pbool remove_garbage);
  394. extern int init_record_cache(RECORD_CACHE *info,uint cachesize,File file,
  395.                  uint reclength,enum cache_type type,
  396.                  pbool use_async_io);
  397. extern int read_cache_record(RECORD_CACHE *info,byte *to);
  398. extern int end_record_cache(RECORD_CACHE *info);
  399. extern int write_cache_record(RECORD_CACHE *info,my_off_t filepos,
  400.                   const byte *record,uint length);
  401. extern int flush_write_cache(RECORD_CACHE *info);
  402. extern long my_clock(void);
  403. extern sig_handler sigtstp_handler(int signal_number);
  404. extern void handle_recived_signals(void);
  405. extern int init_key_cache(ulong use_mem,ulong leave_this_much_mem);
  406. extern byte *key_cache_read(File file,my_off_t filepos,byte* buff,uint length,
  407.                 uint block_length,int return_buffer);
  408. extern int key_cache_write(File file,my_off_t filepos,byte* buff,uint length,
  409.                uint block_length,int force_write);
  410. extern int flush_key_blocks(int file,pbool free_used_blocks);
  411. extern void end_key_cache(void);
  412. extern sig_handler my_set_alarm_variable(int signo);
  413. extern void my_string_ptr_sort(void *base,uint items,size_s size);
  414. extern void radixsort_for_str_ptr(uchar* base[], uint number_of_elements,
  415.                   size_s size_of_element,uchar *buffer[]);
  416. extern int init_io_cache(IO_CACHE *info,File file,uint cachesize,
  417.              enum cache_type type,my_off_t seek_offset,
  418.              pbool use_async_io, myf cache_myflags);
  419. extern void reinit_io_cache(IO_CACHE *info,enum cache_type type,
  420.                 my_off_t seek_offset,pbool use_async_io);
  421. extern int _my_b_read(IO_CACHE *info,byte *Buffer,uint Count);
  422. extern int _my_b_net_read(IO_CACHE *info,byte *Buffer,uint Count);
  423. extern int _my_b_get(IO_CACHE *info);
  424. extern int _my_b_async_read(IO_CACHE *info,byte *Buffer,uint Count);
  425. extern int _my_b_write(IO_CACHE *info,const byte *Buffer,uint Count);
  426. extern int flush_io_cache(IO_CACHE *info);
  427. extern int end_io_cache(IO_CACHE *info);
  428. extern int open_cacheed_file(IO_CACHE *cache,const char *dir,
  429.                  const char *prefix, uint cache_size);
  430. extern void close_cacheed_file(IO_CACHE *cache);
  431. extern my_bool init_dynamic_array(DYNAMIC_ARRAY *array,uint element_size,
  432.                   uint init_alloc,uint alloc_increment);
  433. extern my_bool insert_dynamic(DYNAMIC_ARRAY *array,gptr element);
  434. extern byte *alloc_dynamic(DYNAMIC_ARRAY *array);
  435. extern byte *pop_dynamic(DYNAMIC_ARRAY*);
  436. extern my_bool set_dynamic(DYNAMIC_ARRAY *array,gptr element,uint index);
  437. extern void get_dynamic(DYNAMIC_ARRAY *array,gptr element,uint index);
  438. extern void delete_dynamic(DYNAMIC_ARRAY *array);
  439. extern void delete_dynamic_element(DYNAMIC_ARRAY *array, uint index);
  440. extern void freeze_size(DYNAMIC_ARRAY *array);
  441. #define dynamic_array_ptr(array,index) ((array)->buffer+(index)*(array)->size_of_element)
  442. #define dynamic_element(array,index,type) ((type)((array)->buffer) +(index))
  443. #define push_dynamic(A,B) insert_dynamic(A,B)
  444.  
  445. extern int find_type(my_string x,TYPELIB *typelib,uint full_name);
  446. extern void make_type(my_string to,uint nr,TYPELIB *typelib);
  447. extern my_string get_type(TYPELIB *typelib,uint nr);
  448. extern my_bool init_dynamic_string(DYNAMIC_STRING *str, my_string init_str,
  449.                    uint init_alloc,uint alloc_increment);
  450. extern my_bool dynstr_append(DYNAMIC_STRING *str, my_string append);
  451. extern my_bool dynstr_set(DYNAMIC_STRING *str, my_string init_str);
  452. extern my_bool dynstr_realloc(DYNAMIC_STRING *str, ulong additional_size);
  453. extern void dynstr_free(DYNAMIC_STRING *str);
  454. void set_all_changeable_vars(CHANGEABLE_VAR *vars);
  455. my_bool set_changeable_var(my_string str,CHANGEABLE_VAR *vars);
  456. my_bool set_changeable_varval(const char *var, ulong val,
  457.                   CHANGEABLE_VAR *vars);
  458. #ifdef HAVE_MLOCK
  459. extern byte *my_malloc_lock(uint length,myf flags);
  460. extern void my_free_lock(byte *ptr,myf flags);
  461. #else
  462. #define my_malloc_lock(A,B) my_malloc((A),(B))
  463. #define my_free_lock(A,B) my_free((A),(B))
  464. #endif
  465. void init_alloc_root(MEM_ROOT *mem_root,uint block_size);
  466. gptr alloc_root(MEM_ROOT *mem_root,unsigned int Size);
  467. void free_root(MEM_ROOT *root);
  468. char *strdup_root(MEM_ROOT *root,const char *str);
  469. char *memdup_root(MEM_ROOT *root,const char *str,uint len);
  470. void load_defaults(const char *conf_file, my_string *groups,
  471.            int *argc, char ***argv);
  472. void free_defaults(char **argv);
  473. my_bool my_compress(byte *, ulong *, ulong *);
  474. my_bool my_uncompress(byte *, ulong *, ulong *);
  475. byte *my_compress_alloc(const byte *packet, ulong *len, ulong *complen);
  476.  
  477. #if defined(_MSC_VER) && !defined(__WIN32__)
  478. extern void sleep(int sec);
  479. #endif
  480. #ifdef __WIN32__
  481. extern my_bool have_tcpip;        /* Is set if tcpip is used */
  482. #endif
  483.  
  484. #ifdef    __cplusplus
  485. }
  486. #endif
  487. #endif /* _my_sys_h */
  488.